(function webpackUniversalModuleDefinition(root, factory) {
	if (typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if (typeof define === 'function' && define.amd)
		define([], factory);
	else {
		var a = factory();
		for (var i in a)(typeof exports === 'object' ? exports : root)[i] = a[i];
	}
})(this, function() {
	return /******/ (function(modules) { // webpackBootstrap
		/******/ // The module cache
		/******/
		var installedModules = {};
		/******/
		/******/ // The require function
		/******/
		function __webpack_require__(moduleId) {
			/******/
			/******/ // Check if module is in cache
			/******/
			if (installedModules[moduleId]) {
				/******/
				return installedModules[moduleId].exports;
				/******/
			}
			/******/ // Create a new module (and put it into the cache)
			/******/
			var module = installedModules[moduleId] = {
				/******/
				i: moduleId,
				/******/
				l: false,
				/******/
				exports: {}
				/******/
			};
			/******/
			/******/ // Execute the module function
			/******/
			modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
			/******/
			/******/ // Flag the module as loaded
			/******/
			module.l = true;
			/******/
			/******/ // Return the exports of the module
			/******/
			return module.exports;
			/******/
		}
		/******/
		/******/
		/******/ // expose the modules object (__webpack_modules__)
		/******/
		__webpack_require__.m = modules;
		/******/
		/******/ // expose the module cache
		/******/
		__webpack_require__.c = installedModules;
		/******/
		/******/ // identity function for calling harmony imports with the correct context
		/******/
		__webpack_require__.i = function(value) {
			return value;
		};
		/******/
		/******/ // define getter function for harmony exports
		/******/
		__webpack_require__.d = function(exports, name, getter) {
			/******/
			if (!__webpack_require__.o(exports, name)) {
				/******/
				Object.defineProperty(exports, name, {
					/******/
					configurable: false,
					/******/
					enumerable: true,
					/******/
					get: getter
					/******/
				});
				/******/
			}
			/******/
		};
		/******/
		/******/ // getDefaultExport function for compatibility with non-harmony modules
		/******/
		__webpack_require__.n = function(module) {
			/******/
			var getter = module && module.__esModule ?
				/******/
				function getDefault() {
					return module['default'];
				} :
				/******/
				function getModuleExports() {
					return module;
				};
			/******/
			__webpack_require__.d(getter, 'a', getter);
			/******/
			return getter;
			/******/
		};
		/******/
		/******/ // Object.prototype.hasOwnProperty.call
		/******/
		__webpack_require__.o = function(object, property) {
			return Object.prototype.hasOwnProperty.call(object, property);
		};
		/******/
		/******/ // __webpack_public_path__
		/******/
		__webpack_require__.p = "";
		/******/
		/******/ // Load entry module and return exports
		/******/
		return __webpack_require__(__webpack_require__.s = 13);
		/******/
	})
	/************************************************************************/
	/******/
	([
		/* 0 */
		/***/
		(function(module, exports, __webpack_require__) {

			"use strict";


			var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
				return typeof obj;
			} : function(obj) {
				return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" :
					typeof obj;
			};

			module.exports = {
				type: function type(ob) {
					return Object.prototype.toString.call(ob).slice(8, -1).toLowerCase();
				},
				isObject: function isObject(ob, real) {
					if (real) {
						return this.type(ob) === "object";
					} else {
						return ob && (typeof ob === 'undefined' ? 'undefined' : _typeof(ob)) === 'object';
					}
				},
				isFormData: function isFormData(val) {
					return typeof FormData !== 'undefined' && val instanceof FormData;
				},
				trim: function trim(str) {
					return str.replace(/(^\s*)|(\s*$)/g, '');
				},
				encode: function encode(val) {
					return encodeURIComponent(val).replace(/%40/gi, '@').replace(/%3A/gi, ':').replace(/%24/g, '$').replace(
						/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
				},
				formatParams: function formatParams(data) {
					var str = "";
					var first = true;
					var that = this;
					if (!this.isObject(data)) {
						return data;
					}

					function _encode(sub, path) {
						var encode = that.encode;
						var type = that.type(sub);
						if (type == "array") {
							sub.forEach(function(e, i) {
								if (!that.isObject(e)) i = "";
								_encode(e, path + ('%5B' + i + '%5D'));
							});
						} else if (type == "object") {
							for (var key in sub) {
								if (path) {
									_encode(sub[key], path + "%5B" + encode(key) + "%5D");
								} else {
									_encode(sub[key], encode(key));
								}
							}
						} else {
							if (!first) {
								str += "&";
							}
							first = false;
							str += path + "=" + encode(sub);
						}
					}

					_encode(data, "");
					return str;
				},

				// Do not overwrite existing attributes
				merge: function merge(a, b) {
					for (var key in b) {
						if (!a.hasOwnProperty(key)) {
							a[key] = b[key];
						} else if (this.isObject(b[key], 1) && this.isObject(a[key], 1)) {
							this.merge(a[key], b[key]);
						}
					}
					return a;
				}
			};

			/***/
		}),
		/* 1 */
		/***/
		(function(module, exports, __webpack_require__) {

			function KEEP(_, cb) {
				cb();
			}
			"use strict";

			var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
				return typeof obj;
			} : function(obj) {
				return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" :
					typeof obj;
			};

			var _createClass = function() {
				function defineProperties(target, props) {
					for (var i = 0; i < props.length; i++) {
						var descriptor = props[i];
						descriptor.enumerable = descriptor.enumerable || false;
						descriptor.configurable = true;
						if ("value" in descriptor) descriptor.writable = true;
						Object.defineProperty(target, descriptor.key, descriptor);
					}
				}
				return function(Constructor, protoProps, staticProps) {
					if (protoProps) defineProperties(Constructor.prototype, protoProps);
					if (staticProps) defineProperties(Constructor, staticProps);
					return Constructor;
				};
			}();

			function _classCallCheck(instance, Constructor) {
				if (!(instance instanceof Constructor)) {
					throw new TypeError("Cannot call a class as a function");
				}
			}

			/*
			 * author: wendu
			 * email: 824783146@qq.com
			 **/

			var util = __webpack_require__(0);
			var isBrowser = typeof document !== "undefined";

			//EngineWrapper can help  generating  a  http engine quickly through a adapter
			function EngineWrapper(adapter) {
				var AjaxEngine = function() {
					function AjaxEngine() {
						_classCallCheck(this, AjaxEngine);

						this.requestHeaders = {};
						this.readyState = 0;
						this.timeout = 0; // 0 stands for no timeout
						this.responseURL = "";
						this.responseHeaders = {};
					}

					_createClass(AjaxEngine, [{
						key: "_call",
						value: function _call(name) {
							this[name] && this[name].apply(this, [].splice.call(arguments, 1));
						}
					}, {
						key: "_changeReadyState",
						value: function _changeReadyState(state) {
							this.readyState = state;
							this._call("onreadystatechange");
						}
					}, {
						key: "open",
						value: function open(method, url) {
							this.method = method;
							if (!url) {
								url = location.href;
							} else {
								url = util.trim(url);
								if (url.indexOf("http") !== 0) {
									// Normalize the request url
									if (isBrowser) {
										var t = document.createElement("a");
										t.href = url;
										url = t.href;
									}
								}
							}
							this.responseURL = url;
							this._changeReadyState(1);
						}
					}, {
						key: "send",
						value: function send(arg) {
							var _this = this;

							arg = arg || null;
							var self = this;
							if (adapter) {
								var request = {
									method: self.method,
									url: self.responseURL,
									headers: self.requestHeaders || {},
									body: arg
								};
								util.merge(request, self._options || {});
								if (request.method === "GET") {
									request.body = null;
								}
								self._changeReadyState(3);
								var timer = void 0;
								self.timeout = self.timeout || 0;
								if (self.timeout > 0) {
									timer = setTimeout(function() {
										if (self.readyState === 3) {
											_this._call("onloadend");
											self._changeReadyState(0);
											self._call("ontimeout");
										}
									}, self.timeout);
								}
								request.timeout = self.timeout;
								adapter(request, function(response) {

									function getAndDelete(key) {
										var t = response[key];
										delete response[key];
										return t;
									}

									// If the request has already timeout, return
									if (self.readyState !== 3) return;
									clearTimeout(timer);

									// Make sure the type of status is integer
									self.status = getAndDelete("statusCode") - 0;

									var responseText = getAndDelete("responseText");
									var statusMessage = getAndDelete("statusMessage");

									// Network error, set the status code 0
									if (!self.status) {
										self.statusText = responseText;
										self._call("onerror", {
											msg: statusMessage
										});
									} else {
										// Parsing the response headers to array in a object,  because
										// there may be multiple values with the same header name
										var responseHeaders = getAndDelete("headers");
										var headers = {};
										for (var field in responseHeaders) {
											var value = responseHeaders[field];
											var key = field.toLowerCase();
											// Is array
											if ((typeof value === "undefined" ? "undefined" : _typeof(value)) === "object") {
												headers[key] = value;
											} else {
												headers[key] = headers[key] || [];
												headers[key].push(value);
											}
										}
										var cookies = headers["set-cookie"];
										if (isBrowser && cookies) {
											cookies.forEach(function(e) {
												// Remove the http-Only property of the  cookie
												// so that JavaScript can operate it.
												document.cookie = e.replace(/;\s*httpOnly/ig, "");
											});
										}
										self.responseHeaders = headers;
										// Set the fields of engine from response
										self.statusText = statusMessage || "";
										self.response = self.responseText = responseText;
										self._response = response;
										self._changeReadyState(4);
										self._call("onload");
									}
									self._call("onloadend");
								});
							} else {
								console.error("Ajax require adapter");
							}
						}
					}, {
						key: "setRequestHeader",
						value: function setRequestHeader(key, value) {
							this.requestHeaders[util.trim(key)] = value;
						}
					}, {
						key: "getResponseHeader",
						value: function getResponseHeader(key) {
							return (this.responseHeaders[key.toLowerCase()] || "").toString() || null;
						}
					}, {
						key: "getAllResponseHeaders",
						value: function getAllResponseHeaders() {
							var str = "";
							for (var key in this.responseHeaders) {
								str += key + ":" + this.getResponseHeader(key) + "\r\n";
							}
							return str || null;
						}
					}, {
						key: "abort",
						value: function abort(msg) {
							this._changeReadyState(0);
							this._call("onerror", {
								msg: msg
							});
							this._call("onloadend");
						}
					}], [{
						key: "setAdapter",
						value: function setAdapter(requestAdapter) {
							adapter = requestAdapter;
						}
					}]);

					return AjaxEngine;
				}();

				return AjaxEngine;
			}

			// learn more about keep-loader: https://github.com/wendux/keep-loader
			;
			module.exports = EngineWrapper;

			/***/
		}),
		/* 2 */
		/***/
		(function(module, exports, __webpack_require__) {

			function KEEP(_, cb) {
				cb();
			}
			"use strict";

			var _createClass = function() {
				function defineProperties(target, props) {
					for (var i = 0; i < props.length; i++) {
						var descriptor = props[i];
						descriptor.enumerable = descriptor.enumerable || false;
						descriptor.configurable = true;
						if ("value" in descriptor) descriptor.writable = true;
						Object.defineProperty(target, descriptor.key, descriptor);
					}
				}
				return function(Constructor, protoProps, staticProps) {
					if (protoProps) defineProperties(Constructor.prototype, protoProps);
					if (staticProps) defineProperties(Constructor, staticProps);
					return Constructor;
				};
			}();

			function _classCallCheck(instance, Constructor) {
				if (!(instance instanceof Constructor)) {
					throw new TypeError("Cannot call a class as a function");
				}
			}

			var utils = __webpack_require__(0);
			var isBrowser = typeof document !== "undefined";

			var Fly = function() {
				function Fly(engine) {
					_classCallCheck(this, Fly);

					this.engine = engine || XMLHttpRequest;

					this.default = this; //For typeScript

					/**
					 * Add  lock/unlock API for interceptor.
					 *
					 * Once an request/response interceptor is locked, the incoming request/response
					 * will be added to a queue before they enter the interceptor, they will not be
					 * continued  until the interceptor is unlocked.
					 *
					 * @param [interceptor] either is interceptors.request or interceptors.response
					 */
					function wrap(interceptor) {
						var resolve = void 0;
						var reject = void 0;

						function _clear() {
							interceptor.p = resolve = reject = null;
						}

						utils.merge(interceptor, {
							lock: function lock() {
								if (!resolve) {
									interceptor.p = new Promise(function(_resolve, _reject) {
										resolve = _resolve;
										reject = _reject;
									});
								}
							},
							unlock: function unlock() {
								if (resolve) {
									resolve();
									_clear();
								}
							},
							clear: function clear() {
								if (reject) {
									reject("cancel");
									_clear();
								}
							}
						});
					}

					var interceptors = this.interceptors = {
						response: {
							use: function use(handler, onerror) {
								this.handler = handler;
								this.onerror = onerror;
							}
						},
						request: {
							use: function use(handler) {
								this.handler = handler;
							}
						}
					};

					var irq = interceptors.request;
					var irp = interceptors.response;
					wrap(irp);
					wrap(irq);

					this.config = {
						method: "GET",
						baseURL: "",
						headers: {},
						timeout: 0,
						params: {}, // Default Url params
						parseJson: true, // Convert response data to JSON object automatically.
						withCredentials: false
					};
				}

				_createClass(Fly, [{
					key: "request",
					value: function request(url, data, options) {
						var _this = this;

						var engine = new this.engine();
						var contentType = "Content-Type";
						var contentTypeLowerCase = contentType.toLowerCase();
						var interceptors = this.interceptors;
						var requestInterceptor = interceptors.request;
						var responseInterceptor = interceptors.response;
						var requestInterceptorHandler = requestInterceptor.handler;
						var promise = new Promise(function(resolve, reject) {
							if (utils.isObject(url)) {
								options = url;
								url = options.url;
							}
							options = options || {};
							options.headers = options.headers || {};

							function isPromise(p) {
								// some  polyfill implementation of Promise may be not standard,
								// so, we test by duck-typing
								return p && p.then && p.catch;
							}

							/**
							 * If the request/response interceptor has been locked，
							 * the new request/response will enter a queue. otherwise, it will be performed directly.
							 * @param [promise] if the promise exist, means the interceptor is  locked.
							 * @param [callback]
							 */
							function enqueueIfLocked(promise, callback) {
								if (promise) {
									promise.then(function() {
										callback();
									});
								} else {
									callback();
								}
							}

							// make the http request
							function makeRequest(options) {
								data = options.body;
								// Normalize the request url
								url = utils.trim(options.url);
								var baseUrl = utils.trim(options.baseURL || "");
								if (!url && isBrowser && !baseUrl) url = location.href;
								if (url.indexOf("http") !== 0) {
									var isAbsolute = url[0] === "/";
									if (!baseUrl && isBrowser) {
										var arr = location.pathname.split("/");
										arr.pop();
										baseUrl = location.protocol + "//" + location.host + (isAbsolute ? "" : arr.join("/"));
									}
									if (baseUrl[baseUrl.length - 1] !== "/") {
										baseUrl += "/";
									}
									url = baseUrl + (isAbsolute ? url.substr(1) : url);
									if (isBrowser) {

										// Normalize the url which contains the ".." or ".", such as
										// "http://xx.com/aa/bb/../../xx" to "http://xx.com/xx" .
										var t = document.createElement("a");
										t.href = url;
										url = t.href;
									}
								}

								var responseType = utils.trim(options.responseType || "");
								var needQuery = ["GET", "HEAD", "DELETE", "OPTION"].indexOf(options.method) !== -1;
								var dataType = utils.type(data);
								var params = options.params || {};

								// merge url params when the method is "GET" (data is object)
								if (needQuery && dataType === "object") {
									params = utils.merge(data, params);
								}
								// encode params to String
								params = utils.formatParams(params);

								// save url params
								var _params = [];
								if (params) {
									_params.push(params);
								}
								// Add data to url params when the method is "GET" (data is String)
								if (needQuery && data && dataType === "string") {
									_params.push(data);
								}

								// make the final url
								if (_params.length > 0) {
									url += (url.indexOf("?") === -1 ? "?" : "&") + _params.join("&");
								}

								engine.open(options.method, url);

								// try catch for ie >=9
								try {
									engine.withCredentials = !!options.withCredentials;
									engine.timeout = options.timeout || 0;
									if (responseType !== "stream") {
										engine.responseType = responseType;
									}
								} catch (e) {}

								var customContentType = options.headers[contentType] || options.headers[contentTypeLowerCase];

								// default content type
								var _contentType = "application/x-www-form-urlencoded";
								// If the request data is json object, transforming it  to json string,
								// and set request content-type to "json". In browser,  the data will
								// be sent as RequestBody instead of FormData
								if (utils.trim((customContentType || "").toLowerCase()) === _contentType) {
									data = utils.formatParams(data);
								} else if (!utils.isFormData(data) && ["object", "array"].indexOf(utils.type(data)) !== -1) {
									_contentType = 'application/json;charset=utf-8';
									data = JSON.stringify(data);
								}
								//If user doesn't set content-type, set default.
								if (!(customContentType || needQuery)) {
									options.headers[contentType] = _contentType;
								}

								for (var k in options.headers) {
									if (k === contentType && utils.isFormData(data)) {
										// Delete the content-type, Let the browser set it
										delete options.headers[k];
									} else {
										try {
											// In browser environment, some header fields are readonly,
											// write will cause the exception .
											engine.setRequestHeader(k, options.headers[k]);
										} catch (e) {}
									}
								}

								function onresult(handler, data, type) {
									enqueueIfLocked(responseInterceptor.p, function() {
										if (handler) {
											//如果失败，添加请求信息
											if (type) {
												data.request = options;
											}
											var ret = handler.call(responseInterceptor, data, Promise);
											data = ret === undefined ? data : ret;
										}
										if (!isPromise(data)) {
											data = Promise[type === 0 ? "resolve" : "reject"](data);
										}
										data.then(function(d) {
											resolve(d);
										}).catch(function(e) {
											reject(e);
										});
									});
								}

								function onerror(e) {
									e.engine = engine;
									onresult(responseInterceptor.onerror, e, -1);
								}

								function Err(msg, status) {
									this.message = msg;
									this.status = status;
								}

								engine.onload = function() {
									try {
										// The xhr of IE9 has not response field
										var response = engine.response || engine.responseText;
										if (response && options.parseJson && (engine.getResponseHeader(contentType) || "").indexOf("json") !==
											-1
											// Some third engine implementation may transform the response text to json object automatically,
											// so we should test the type of response before transforming it
											&&
											!utils.isObject(response)) {
											response = JSON.parse(response);
										}

										var headers = engine.responseHeaders;
										// In browser
										if (!headers) {
											headers = {};
											var items = (engine.getAllResponseHeaders() || "").split("\r\n");
											items.pop();
											items.forEach(function(e) {
												if (!e) return;
												var key = e.split(":")[0];
												headers[key] = engine.getResponseHeader(key);
											});
										}
										var status = engine.status;
										var statusText = engine.statusText;
										var _data = {
											data: response,
											headers: headers,
											status: status,
											statusText: statusText
										};
										// The _response filed of engine is set in  adapter which be called in engine-wrapper.js
										utils.merge(_data, engine._response);
										if (status >= 200 && status < 300 || status === 304) {
											_data.engine = engine;
											_data.request = options;
											onresult(responseInterceptor.handler, _data, 0);
										} else {
											var e = new Err(statusText, status);
											e.response = _data;
											onerror(e);
										}
									} catch (e) {
										onerror(new Err(e.msg, engine.status));
									}
								};

								engine.onerror = function(e) {
									onerror(new Err(e.msg || "Network Error", 0));
								};

								engine.ontimeout = function() {
									onerror(new Err("timeout [ " + engine.timeout + "ms ]", 1));
								};
								engine._options = options;
								setTimeout(function() {
									engine.send(needQuery ? null : data);
								}, 0);
							}

							enqueueIfLocked(requestInterceptor.p, function() {
								utils.merge(options, JSON.parse(JSON.stringify(_this.config)));
								var headers = options.headers;
								headers[contentType] = headers[contentType] || headers[contentTypeLowerCase] || "";
								delete headers[contentTypeLowerCase];
								options.body = data || options.body;
								url = utils.trim(url || "");
								options.method = options.method.toUpperCase();
								options.url = url;
								var ret = options;
								if (requestInterceptorHandler) {
									ret = requestInterceptorHandler.call(requestInterceptor, options, Promise) || options;
								}
								if (!isPromise(ret)) {
									ret = Promise.resolve(ret);
								}
								ret.then(function(d) {
									//if options continue
									if (d === options) {
										makeRequest(d);
									} else {
										resolve(d);
									}
								}, function(err) {
									reject(err);
								});
							});
						});
						promise.engine = engine;
						return promise;
					}
				}, {
					key: "all",
					value: function all(promises) {
						return Promise.all(promises);
					}
				}, {
					key: "spread",
					value: function spread(callback) {
						return function(arr) {
							return callback.apply(null, arr);
						};
					}
				}]);

				return Fly;
			}();

			//For typeScript


			Fly.default = Fly;

			["get", "post", "put", "patch", "head", "delete"].forEach(function(e) {
				Fly.prototype[e] = function(url, data, option) {
					return this.request(url, data, utils.merge({
						method: e
					}, option));
				};
			});
			["lock", "unlock", "clear"].forEach(function(e) {
				Fly.prototype[e] = function() {
					this.interceptors.request[e]();
				};
			});
			// Learn more about keep-loader: https://github.com/wendux/keep-loader
			;
			module.exports = Fly;

			/***/
		}),
		/* 3 */
		,
		/* 4 */
		,
		/* 5 */
		,
		/* 6 */
		,
		/* 7 */
		/***/
		(function(module, exports, __webpack_require__) {

			"use strict";


			//微信小程序适配器
			module.exports = function(request, responseCallback) {
				var con = {
					method: request.method,
					url: request.url,
					dataType: request.dataType || undefined,
					header: request.headers,
					data: request.body || {},
					responseType: request.responseType || 'text',
					success: function success(res) {
						responseCallback({
							statusCode: res.statusCode,
							responseText: res.data,
							headers: res.header,
							statusMessage: res.errMsg
						});
					},
					fail: function fail(res) {
						responseCallback({
							statusCode: res.statusCode || 0,
							statusMessage: res.errMsg
						});
					}
				};
				wx.request(con);
			};

			/***/
		}),
		/* 8 */
		,
		/* 9 */
		,
		/* 10 */
		,
		/* 11 */
		,
		/* 12 */
		,
		/* 13 */
		/***/
		(function(module, exports, __webpack_require__) {

			"use strict";


			//微信小程序入口
			var _Fly = __webpack_require__(2);
			var EngineWrapper = __webpack_require__(1);
			var adapter = __webpack_require__(7);
			var wxEngine = EngineWrapper(adapter);
			module.exports = function(engine) {
				return new _Fly(engine || wxEngine);
			};

			/***/
		})
		/******/
	]);
});
